#include <iostream>
#include <memory>
// 初始化多次
void shared_ptr_error()
{
    // 一个原始指针初始化多次
    int *p = new int(1);
    std::shared_ptr<int> ptr1(p);
    std::shared_ptr<int> ptr2(p);

    // 结果为：
    // 会出现运行时错误，因为ptr1和ptr2指向的是同一个指针p，当ptr1和ptr2析构时，会调用delete p，导致p被delete两次，出现未定义行为
    // 在我这里是run time error
}
// 循环引用
// 循环引用的例子
struct Node
{
    std::shared_ptr<Node> next;
    int data;
    ~Node()
    {
        std::cout << "Destroying node with data: " << data << std::endl;
    }
};

void circular_reference()
{
    std::shared_ptr<Node> node1(new Node{nullptr, 1});
    std::shared_ptr<Node> node2(new Node{nullptr, 2});

    // 创建循环引用
    node1->next = node2;
    node2->next = node1;

    // 此时node1和node2的引用计数都是2
    std::cout << "node1 reference count: " << node1.use_count() << std::endl;
    std::cout << "node2 reference count: " << node2.use_count() << std::endl;

    // 函数结束时，node1和node2的引用计数减1，但仍然为1
    // 由于相互引用，引用计数永远不会为0
    // 导致内存泄漏，析构函数永远不会被调用
}
// 增加一个shared_from_this()的例子返回this

struct A
{
    // 需要把智能指针this 传递出去但是又是this自己
    std::shared_ptr<A> GetSelf()
    {
        return std::shared_ptr<A>(this); // don't do this!
    }
};

void shared_error2()
{
    std::shared_ptr<A> sp1(new A);
    std::shared_ptr<A> sp2 = sp1->GetSelf();
}
//  所以想要在自己这个类中传出包含自己的智能指针
//  需要继承std::enable_shared_from_this<A>
// enable_shared_from_this的实现就是weak_ptr和shared_ptr的互相转换
class A1 : public std::enable_shared_from_this<A1>
{
public:
    ~A1() { std::cout << "A1 destroyed" << std::endl; }

    std::shared_ptr<A1> GetSelf()
    {
        return shared_from_this();
    }
};
void shared_true2()
{
    std::shared_ptr<A1> sp1(new A1);
    std::shared_ptr<A1> sp2 = sp1->GetSelf();
}

int main()
{
    // shared_ptr_error(); // 这个在这边是不会打印出来东西
    //  shared_error2();//这个在这边是直接运行报错了 内存错误了
    shared_true2();
    std::cout << "结束" << std::endl;
    return 0;
}
